{
  "cells": [
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Fairness with Adaptive Weights\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 数据预处理\n",
        "\n",
        "对数据进行了加载、拆分、独热编码、标准化和划分等预处理操作，并将准备好的数据集用于后续的逻辑回归模型训练。\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "etmGLa8X6jep"
      },
      "outputs": [],
      "source": [
        "#load data\n",
        "\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn import preprocessing\n",
        "\n",
        "# 加载数据\n",
        "data = pd.read_csv(\"compas-scores-two-years.csv\")\n",
        "data = pd.DataFrame(data)\n",
        "# 数据预处理\n",
        "data_w = data[data['race'] == 'Caucasian']\n",
        "data_b = data[data['race'] == 'African-American']\n",
        "\n",
        "data = pd.concat([data_w, data_b])\n",
        "\n",
        "for col in set(data.columns) - set(data.describe().columns):\n",
        "    data[col] = data[col].astype('category')\n",
        "\n",
        "def clip(df, a):\n",
        "    perm = np.random.permutation(df.index)\n",
        "    m = len(df.index)\n",
        "    clip_end = int(a*m)\n",
        "    cliped = df.iloc[:clip_end]\n",
        "    return cliped\n",
        "\n",
        "def oneHotCatVars(df, df_cols):\n",
        "    '''\n",
        "    oneHotCatVars 类别变量独热编码\n",
        "\n",
        "    函数中，首先将不是类别变量的列存储在df_1中，然后使用pd.get_dummies函数对类别变量的列进行独热编码，得到编码后的DataFrame，存储在df_2中。\n",
        "    最后，使用pd.concat函数将df_1和df_2沿着列方向进行合并，得到编码后的最终DataFrame。\n",
        "    '''\n",
        "    df_1 = df.drop(columns = df_cols, axis = 1)\n",
        "    df_2 = pd.get_dummies(df[df_cols])\n",
        "\n",
        "    return (pd.concat([df_1, df_2], axis=1, join='inner'))\n",
        "\n",
        "data_preprocessed = oneHotCatVars(data, data.select_dtypes('category').columns)\n",
        "\n",
        "\n",
        "normalize_columns = ['age', 'juv_fel_count', 'juv_misd_count', 'juv_other_count', 'priors_count']\n",
        "\n",
        "def normalize(columns):\n",
        "    '''\n",
        "    数据归一化\n",
        "\n",
        "    用于对指定的列进行标准化处理。\n",
        "    在函数内部，使用preprocessing.StandardScaler创建一个标准化器scaler。\n",
        "    然后，对data_preprocessed中的指定列columns进行标准化，即将数据按列减去均值并除以标准差。\n",
        "    '''\n",
        "    scaler = preprocessing.StandardScaler()\n",
        "    data_preprocessed[columns] = scaler.fit_transform(data_preprocessed[columns])\n",
        "\n",
        "normalize(normalize_columns)\n",
        "# 数据集划分\n",
        "x_train, x_test = train_test_split(data_preprocessed)\n",
        "# 划分测试集中的子集\n",
        "b_test = x_test[x_test['race_African-American'] == 1]\n",
        "w_test = x_test[x_test['race_Caucasian'] == 1]\n",
        "# 数据准备\n",
        "train = x_train.drop(['two_year_recid'],axis=1)\n",
        "train = train.drop(['race_African-American'],axis=1)\n",
        "train = train.drop(['race_Caucasian'],axis=1)\n",
        "train_label = x_train['two_year_recid']\n",
        "test_x = x_test.drop(['two_year_recid'],axis=1)\n",
        "test_x = test_x.drop(['race_African-American'],axis=1)\n",
        "test_x = test_x.drop(['race_Caucasian'],axis=1)\n",
        "test_label = x_test['two_year_recid']\n",
        "b_test_x = b_test.drop(['two_year_recid'],axis=1)\n",
        "b_test_x = b_test_x.drop(['race_African-American'],axis=1)\n",
        "b_test_x = b_test_x.drop(['race_Caucasian'],axis=1)\n",
        "b_test_y = b_test['two_year_recid']\n",
        "w_test_x = w_test.drop(['two_year_recid'],axis=1)\n",
        "w_test_x = w_test_x.drop(['race_African-American'],axis=1)\n",
        "w_test_x = w_test_x.drop(['race_Caucasian'],axis=1)\n",
        "w_test_y = w_test['two_year_recid']"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 模型拟合与评估\n",
        "\n",
        "通过逻辑回归分类器对不同种族的样本进行预测，并评估了分类器在各个子集上的性能指标，最后输出了各项指标的结果\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "FFBHRhqrSlNb"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>ALL</th>\n",
              "      <th>DP</th>\n",
              "      <th>TPR</th>\n",
              "      <th>TNR</th>\n",
              "      <th>FPR</th>\n",
              "      <th>FNR</th>\n",
              "      <th>ACR</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>logistic_reg_Black</th>\n",
              "      <td>907</td>\n",
              "      <td>0.5072</td>\n",
              "      <td>0.6821</td>\n",
              "      <td>0.6674</td>\n",
              "      <td>0.3326</td>\n",
              "      <td>0.3179</td>\n",
              "      <td>0.6748</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                    ALL      DP     TPR     TNR     FPR     FNR     ACR\n",
              "logistic_reg_Black  907  0.5072  0.6821  0.6674  0.3326  0.3179  0.6748"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>ALL</th>\n",
              "      <th>DP</th>\n",
              "      <th>TPR</th>\n",
              "      <th>TNR</th>\n",
              "      <th>FPR</th>\n",
              "      <th>FNR</th>\n",
              "      <th>ACR</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>logistic_reg_White</th>\n",
              "      <td>631</td>\n",
              "      <td>0.2948</td>\n",
              "      <td>0.4223</td>\n",
              "      <td>0.7895</td>\n",
              "      <td>0.2105</td>\n",
              "      <td>0.5777</td>\n",
              "      <td>0.6434</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                    ALL      DP     TPR     TNR     FPR     FNR     ACR\n",
              "logistic_reg_White  631  0.2948  0.4223  0.7895  0.2105  0.5777  0.6434"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>ALL</th>\n",
              "      <th>DP</th>\n",
              "      <th>TPR</th>\n",
              "      <th>TNR</th>\n",
              "      <th>FPR</th>\n",
              "      <th>FNR</th>\n",
              "      <th>ACR</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>logistic_reg_All</th>\n",
              "      <td>1538</td>\n",
              "      <td>0.42</td>\n",
              "      <td>0.5895</td>\n",
              "      <td>0.723</td>\n",
              "      <td>0.277</td>\n",
              "      <td>0.4105</td>\n",
              "      <td>0.6619</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                   ALL    DP     TPR    TNR    FPR     FNR     ACR\n",
              "logistic_reg_All  1538  0.42  0.5895  0.723  0.277  0.4105  0.6619"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Baseline method: Average accuracy is 66.1899%, Disparate impact is 21.2396%, disparate TPR is 25.9808%,\n",
            " disparate TNR is 12.2073%, p% rule is 58.121%.\n"
          ]
        }
      ],
      "source": [
        "#vanilla classifier\n",
        "\n",
        "def model_eval(actual, pred):\n",
        "    '''\n",
        "    用于评估分类模型的性能。\n",
        "\n",
        "    函数接受两个参数：实际标签actual和预测标签pred。\n",
        "\n",
        "    函数内部首先使用pd.crosstab函数计算混淆矩阵，并将其存储在confusion中。\n",
        "\n",
        "    然后，根据混淆矩阵的各个元素，计算出分类器的性能指标，包括：全部样本数量（'ALL'）、消极预测比率（'DP'）、真正例率（'TPR'）、真负例率（'TNR'）、假正例率（'FPR'）、假负例率（'FNR'）和准确率（'ACR'）。\n",
        "\n",
        "    最后，将计算得到的性能指标以字典的形式返回。\n",
        "    '''\n",
        "    confusion = pd.crosstab(actual, pred, rownames=['Actual'], colnames=['Predicted'])\n",
        "    TP = confusion.loc[1,1]\n",
        "    TN = confusion.loc[0,0]\n",
        "    FP = confusion.loc[0,1]\n",
        "    FN = confusion.loc[1,0]\n",
        "\n",
        "    return {\n",
        "        'ALL': TP + TN + FP + FN,\n",
        "        'DP': (TP + FP) / (TP + TN + FP + FN),\n",
        "        'TPR': TP / (TP + FN),\n",
        "        'TNR': TN / (FP + TN),\n",
        "        'FPR': FP / (FP + TN),\n",
        "        'FNR': FN / (TP + FN),\n",
        "        'ACR': (TP + TN) / (TP + TN + FP + FN),\n",
        "    }\n",
        "\n",
        "# 创建逻辑回归分类器\n",
        "log_reg = LogisticRegression(penalty = 'l2', dual = False, tol = 1e-4, fit_intercept = False, \n",
        "                            max_iter=400, solver='newton-cg', warm_start = True) # 设置一系列参数\n",
        "log_reg.fit(train, train_label) # 拟合逻辑回归模型\n",
        "# 进行预测和评估\n",
        "log_reg_pred1 = log_reg.predict(b_test_x)\n",
        "logistic_reg1 = model_eval(b_test_y, log_reg_pred1) # 得到模型在该子集上的性能评估结果\n",
        "ovl_logreg1 = round(pd.DataFrame([logistic_reg1], index = ['logistic_reg_Black']),4)\n",
        "display(ovl_logreg1) # display函数显示ovl_logreg1的内容\n",
        "# 类似地，对种族为\"Caucasian\"的测试集w_test_x和所有样本的测试集test_x进行预测和评估\n",
        "log_reg_pred2 = log_reg.predict(w_test_x)\n",
        "logistic_reg2 = model_eval(w_test_y, log_reg_pred2)\n",
        "ovl_logreg2 = round(pd.DataFrame([logistic_reg2], index = ['logistic_reg_White']),4)\n",
        "display(ovl_logreg2)\n",
        "\n",
        "log_reg_pred3 = log_reg.predict(test_x)\n",
        "logistic_reg3 = model_eval(test_label, log_reg_pred3)\n",
        "ovl_logreg3 = round(pd.DataFrame([logistic_reg3], index = ['logistic_reg_All']),4)\n",
        "display(ovl_logreg3)\n",
        "# 计算差异和规则\n",
        "\n",
        "# 计算种族为\"Caucasian\"和\"African-American\"两个子集之间的消极预测比率差异（DI）、真负例率差异（DFPR）和真正例率差异（DFNR），并将结果分别存储在DI、DFPR和DFNR中。\n",
        "DI = round(100 * abs(logistic_reg2['DP'] - logistic_reg1['DP']), 4)\n",
        "DFPR = round(100 * abs(logistic_reg2['TNR'] - logistic_reg1['TNR']), 4)\n",
        "DFNR = round(100 * abs(logistic_reg2['TPR'] - logistic_reg1['TPR']), 4)\n",
        "# 计算种族为\"Caucasian\"和\"African-American\"两个子集之间的p%规则（prule），并将结果存储在prule中。\n",
        "prule = round(100 * min(logistic_reg2['DP'] / logistic_reg1['DP'], logistic_reg1['DP'] / logistic_reg2['DP']), 4)\n",
        "# 计算所有样本的准确率（ACR），并将结果存储在ACR中。\n",
        "ACR = round(logistic_reg3['ACR']*100, 4)\n",
        "\n",
        "print(f'Baseline method: Average accuracy is {ACR}%, Disparate impact is {DI}%, disparate TPR is {DFNR}%,\\n disparate TNR is {DFPR}%, p% rule is {prule}%.')"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 自适应权重\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "szA42CNBoL28"
      },
      "outputs": [],
      "source": [
        "from sklearn.metrics import log_loss\n",
        "import math\n",
        "import cvxpy as cp # 用于求解凸优化问题\n",
        "\n",
        "# wi0和wi1：分别初始化了两个权重向量，wi0的所有元素都为1，wi1的所有元素都为1e13（一个非常大的数）。\n",
        "wi0 = np.ones((x_train.shape[0]))\n",
        "wi1 = wi0 + 10000000000000\n",
        "\n",
        "# x_train_b、x_train_bp、x_train_bn、x_train_w、x_train_wp、x_train_wn：通过根据条件筛选出特定种族和特定标签的数据子集，分别存储了训练集中属于不同种族和不同标签的样本。\n",
        "x_train_b = x_train[x_train['race_African-American'] == 1]\n",
        "x_train_bp = x_train_b[x_train_b['two_year_recid'] == 1]\n",
        "x_train_bn = x_train_b[x_train_b['two_year_recid'] == 0]\n",
        "x_train_w = x_train[x_train['race_Caucasian'] == 1]\n",
        "x_train_wp = x_train_w[x_train_w['two_year_recid'] == 1]\n",
        "x_train_wn = x_train_w[x_train_w['two_year_recid'] == 0]\n",
        "# train_bp、train_bn、train_wp、train_wn：从相应的数据子集中去除了与种族和标签相关的列，用于训练模型。\n",
        "train_bp = x_train_bp.drop(['two_year_recid'],axis=1)\n",
        "train_bp = train_bp.drop(['race_African-American'],axis=1)\n",
        "train_bp = train_bp.drop(['race_Caucasian'],axis=1)\n",
        "# bp_label、bn_label、wp_label、wn_label：分别存储了与种族和标签相关的标签。\n",
        "bp_label = x_train_bp['two_year_recid'].to_numpy()\n",
        "train_bn = x_train_bn.drop(['two_year_recid'],axis=1)\n",
        "train_bn = train_bn.drop(['race_African-American'],axis=1)\n",
        "train_bn = train_bn.drop(['race_Caucasian'],axis=1)\n",
        "bn_label = x_train_bn['two_year_recid'].to_numpy()\n",
        "train_wp = x_train_wp.drop(['two_year_recid'],axis=1)\n",
        "train_wp = train_wp.drop(['race_African-American'],axis=1)\n",
        "train_wp = train_wp.drop(['race_Caucasian'],axis=1)\n",
        "wp_label = x_train_wp['two_year_recid'].to_numpy()\n",
        "train_wn = x_train_wn.drop(['two_year_recid'],axis=1)\n",
        "train_wn = train_wn.drop(['race_African-American'],axis=1)\n",
        "train_wn = train_wn.drop(['race_Caucasian'],axis=1)\n",
        "wn_label = x_train_wn['two_year_recid'].to_numpy()\n",
        "\n",
        "loss_bp = wi0_bp = np.ones(x_train_bp.shape[0])\n",
        "loss_bn = wi0_bn = np.ones(x_train_bn.shape[0])\n",
        "loss_wp = wi0_wp = np.ones(x_train_wp.shape[0])\n",
        "loss_wn = wi0_wn = np.ones(x_train_wn.shape[0])\n",
        "\n",
        "def optim(loss, a, c):\n",
        "    '''\n",
        "    用于求解优化问题\n",
        "    '''\n",
        "    A = loss\n",
        "    x = cp.Variable(loss.shape[0])\n",
        "    objective = cp.Maximize(-a*cp.sum_squares(x)+cp.sum(cp.multiply(A,x))) # 目标函数\n",
        "    constraints = [x >= 0, cp.sum(x) == c]\n",
        "    prob = cp.Problem(objective, constraints)   # 使用cvxpy库求解\n",
        "    result = prob.solve()\n",
        "    for i in range(x.value.shape[0]): # 对求解结果进行一些后处理，将小于阈值或小于0的值设置为0\n",
        "        if abs(x.value[i]) < 0.01 or x.value[i] < 0:\n",
        "            x.value[i] = 0\n",
        "        x.value = x.value\n",
        "    return x.value # 返回求解得到的优化变量\n",
        "\n",
        "def model_eval(actual, pred):\n",
        "    # 用于评估分类模型的性能\n",
        "    # 函数接受两个参数：实际标签actual和预测标签pred。\n",
        "    confusion = pd.crosstab(actual, pred, rownames=['Actual'], colnames=['Predicted']) # 函数内部首先使用pd.crosstab函数计算混淆矩阵，并将其存储在confusion中。\n",
        "    # 然后，根据混淆矩阵的各个元素，计算出分类器的性能指标，包括：全部样本数量（'ALL'）、消极预测比率（'DP'）、真正例率（'TPR'）、真负例率（'TNR'）、假正例率（'FPR'）、假负例率（'FNR'）和准确率（'ACR'）\n",
        "    TP = confusion.loc[1,1]\n",
        "    TN = confusion.loc[0,0]\n",
        "    FP = confusion.loc[0,1]\n",
        "    FN = confusion.loc[1,0]\n",
        "\n",
        "    return { # 将计算得到的性能指标以字典的形式返回\n",
        "        'ALL': TP + TN + FP + FN,\n",
        "        'DP': (TP + FP) / (TP + TN + FP + FN),\n",
        "        'TPR': TP / (TP + FN),\n",
        "        'TNR': TN / (FP + TN),\n",
        "        'FPR': FP / (FP + TN),\n",
        "        'FNR': FN / (TP + FN),\n",
        "        'ACR': (TP + TN) / (TP + TN + FP + FN),\n",
        "    }\n",
        "\n",
        "def dif(a, b):\n",
        "    '''\n",
        "    用于计算两个向量之间的欧氏距离\n",
        "    '''\n",
        "    sum = 0\n",
        "    for i in range(len(a)):\n",
        "        sum += (a[i] - b[i]) ** 2\n",
        "        sum0 = sum ** 0.5\n",
        "    return sum0"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 微调\n",
        "\n",
        "这段代码主要用于随机搜索和交叉验证，以选择最佳的参数配置，并返回训练集和测试集的性能得分"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "8aITr5ltFkUF"
      },
      "outputs": [],
      "source": [
        "from random import sample\n",
        "c = 10000000000000\n",
        "def Random_search(train, folds, param_range, num_param = 10):\n",
        "    '''\n",
        "    接受四个参数：train（训练数据集）、folds（交叉验证折数）、param_range（参数范围）、num_param（随机选取的参数个数，默认为10\n",
        "    '''\n",
        "    trainscore = []\n",
        "    testscore = [] # 用于存储训练和测试的性能得分\n",
        "    K_values = sample(range(param_range[0],param_range[1]),num_param)\n",
        "    K_values.sort() # 从参数范围 param_range 中随机选择 num_param 个值作为 K_values，并对其进行排序。\n",
        "    print('k range:',K_values)\n",
        "    for k in K_values: # 对于每个 k 值，在每个交叉验证折中进行训练和评估。\n",
        "        trainscore_folds = []\n",
        "        testscore_folds = []\n",
        "        for j in range(0, folds): # 对于每个交叉验证折\n",
        "            x_train, x_test = train_test_split(train) # 将训练数据集划分为训练集 x_train 和测试集 x_test。\n",
        "            # 从训练集和测试集中提取特征和标签数据，并进行必要的预处理。\n",
        "            Y_train = x_train['two_year_recid'].to_numpy()\n",
        "            X_train = x_train.drop(['two_year_recid'],axis=1)\n",
        "            X_train = X_train.drop(['race_African-American'],axis=1)\n",
        "            X_train = X_train.drop(['race_Caucasian'],axis=1).to_numpy()\n",
        "            Y_test = x_test['two_year_recid'].to_numpy()\n",
        "            X_test = x_test.drop(['two_year_recid'],axis=1)\n",
        "            X_test = X_test.drop(['race_African-American'],axis=1)\n",
        "            X_test = X_test.drop(['race_Caucasian'],axis=1).to_numpy()\n",
        "            # 初始化一些变量和数据子集。\n",
        "            iter = 0\n",
        "            wi0 = np.ones((X_train.shape[0]))\n",
        "            wi1 = wi0 + 10000000000000\n",
        "            x_train_b = x_train[x_train['race_African-American'] == 1]\n",
        "            x_train_bp = x_train_b[x_train_b['two_year_recid'] == 1]\n",
        "            x_train_bn = x_train_b[x_train_b['two_year_recid'] == 0]\n",
        "            x_train_w = x_train[x_train['race_Caucasian'] == 1]\n",
        "            x_train_wp = x_train_w[x_train_w['two_year_recid'] == 1]\n",
        "            x_train_wn = x_train_w[x_train_w['two_year_recid'] == 0]\n",
        "            train_bp = x_train_bp.drop(['two_year_recid'],axis=1)\n",
        "            train_bp = train_bp.drop(['race_African-American'],axis=1)\n",
        "            train_bp = train_bp.drop(['race_Caucasian'],axis=1).to_numpy()\n",
        "            bp_label = x_train_bp['two_year_recid'].to_numpy()\n",
        "            train_bn = x_train_bn.drop(['two_year_recid'],axis=1)\n",
        "            train_bn = train_bn.drop(['race_African-American'],axis=1)\n",
        "            train_bn = train_bn.drop(['race_Caucasian'],axis=1).to_numpy()\n",
        "            bn_label = x_train_bn['two_year_recid'].to_numpy()\n",
        "            train_wp = x_train_wp.drop(['two_year_recid'],axis=1)\n",
        "            train_wp = train_wp.drop(['race_African-American'],axis=1)\n",
        "            train_wp = train_wp.drop(['race_Caucasian'],axis=1).to_numpy()\n",
        "            wp_label = x_train_wp['two_year_recid'].to_numpy()\n",
        "            train_wn = x_train_wn.drop(['two_year_recid'],axis=1)\n",
        "            train_wn = train_wn.drop(['race_African-American'],axis=1)\n",
        "            train_wn = train_wn.drop(['race_Caucasian'],axis=1).to_numpy()\n",
        "            wn_label = x_train_wn['two_year_recid'].to_numpy()\n",
        "\n",
        "            loss_bp = wi0_bp = np.ones(x_train_bp.shape[0])\n",
        "            loss_bn = wi0_bn = np.ones(x_train_bn.shape[0])\n",
        "            loss_wp = wi0_wp = np.ones(x_train_wp.shape[0])\n",
        "            loss_wn = wi0_wn = np.ones(x_train_wn.shape[0])\n",
        "\n",
        "            while dif(wi0, wi1) > 0.0001: # 训练模型并更新权重，直到满足收敛条件\n",
        "                classifier = LogisticRegression(penalty = 'none', dual = False, tol = 1e-4, fit_intercept = False,\n",
        "                            max_iter=400, solver='newton-cg', warm_start = True)\n",
        "                classifier.fit(X_train, Y_train, wi0)\n",
        "\n",
        "                for i1 in range(train_bp.shape[0]): # 在每个子数据集上计算损失值。\n",
        "                    loss_bp[i1] = -math.log(log_reg.predict_proba(train_bp)[i1][1]+1e-100)\n",
        "\n",
        "                for i2 in range(train_bn.shape[0]):\n",
        "                    loss_bn[i2] = -math.log(log_reg.predict_proba(train_bn)[i2][0]+1e-100)\n",
        "\n",
        "                for i3 in range(train_wp.shape[0]):\n",
        "                    loss_wp[i3] = -math.log(log_reg.predict_proba(train_wp)[i3][1]+1e-100)\n",
        "\n",
        "                for i4 in range(train_wn.shape[0]):\n",
        "                    loss_wn[i4] = -math.log(log_reg.predict_proba(train_wn)[i4][0]+1e-100)\n",
        "                # 求解优化问题，得到更新后的权重\n",
        "                wi1 = wi0\n",
        "                wi0_bp_1 = optim(loss_bp, k, c)\n",
        "                wi0_bn_1 = optim(loss_bn, k, c)\n",
        "                wi0_wp_1 = optim(loss_wp, k, c)\n",
        "                wi0_wn_1 = optim(loss_wn, k, c)\n",
        "                # 将各个子数据集的特征和标签合并，并更新权重向量\n",
        "                X_train = np.concatenate([train_bp, train_bn, train_wp, train_wn])\n",
        "                Y_train = np.concatenate((bp_label, bn_label, wp_label, wn_label))\n",
        "                wi0 = np.concatenate((wi0_bp_1, wi0_bn_1, wi0_wp_1, wi0_wn_1))\n",
        "\n",
        "                iter = iter + 1\n",
        "\n",
        "            # 使用训练好的模型进行预测，并计算测试集和训练集上的性能得分\n",
        "            Y_predicted = classifier.predict(X_test)\n",
        "            testscore_folds.append(np.sum(Y_test == Y_predicted)/len(Y_test))\n",
        "\n",
        "            Y_predicted = classifier.predict(X_train)\n",
        "            # 将得分添加到相应的列表中\n",
        "            trainscore_folds.append(np.sum(Y_train == Y_predicted)/len(Y_train))\n",
        "        # 计算训练集和测试集上的平均性能得分，并将得分和选取的 K_values 返回。\n",
        "        trainscore.append(np.mean(np.array(trainscore_folds)))\n",
        "        testscore.append(np.mean(np.array(testscore_folds)))\n",
        "    return trainscore, testscore , K_values"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "使用随机搜索算法和交叉验证来选择最佳的 K 值，以优化 K 最近邻分类器的性能"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "hK0Xh-MLAaJB"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "k range: [3, 4, 5, 6, 7, 9, 11, 14, 15, 17]\n"
          ]
        }
      ],
      "source": [
        "from sklearn.metrics import accuracy_score # 用于计算准确率\n",
        "import matplotlib.pyplot as plt # 用于可视化\n",
        "import warnings\n",
        "\n",
        "warnings.filterwarnings(\"ignore\") # 忽略警告信息\n",
        "\n",
        "param_min = 1\n",
        "param_max = 20\n",
        "k_fold = 5\n",
        "param_range = (param_min, param_max) # K 值取值范围\n",
        "# 得到的结果存储在 trainscore、testscore 和 K_values 中，可以用于评估和比较不同 K 值的性能表现。\n",
        "trainscore, testscore, K_values = Random_search(x_train, k_fold, param_range)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>K_value</th>\n",
              "      <th>Train score</th>\n",
              "      <th>Test score</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>2</td>\n",
              "      <td>0.704597</td>\n",
              "      <td>0.647528</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>4</td>\n",
              "      <td>0.703036</td>\n",
              "      <td>0.648569</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>5</td>\n",
              "      <td>0.703961</td>\n",
              "      <td>0.641631</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>6</td>\n",
              "      <td>0.703729</td>\n",
              "      <td>0.642151</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>11</td>\n",
              "      <td>0.700029</td>\n",
              "      <td>0.648569</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>12</td>\n",
              "      <td>0.702400</td>\n",
              "      <td>0.647181</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6</th>\n",
              "      <td>15</td>\n",
              "      <td>0.702804</td>\n",
              "      <td>0.655334</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>7</th>\n",
              "      <td>16</td>\n",
              "      <td>0.703209</td>\n",
              "      <td>0.656895</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>8</th>\n",
              "      <td>18</td>\n",
              "      <td>0.704365</td>\n",
              "      <td>0.649783</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>9</th>\n",
              "      <td>19</td>\n",
              "      <td>0.703209</td>\n",
              "      <td>0.651344</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   K_value  Train score  Test score\n",
              "0        2     0.704597    0.647528\n",
              "1        4     0.703036    0.648569\n",
              "2        5     0.703961    0.641631\n",
              "3        6     0.703729    0.642151\n",
              "4       11     0.700029    0.648569\n",
              "5       12     0.702400    0.647181\n",
              "6       15     0.702804    0.655334\n",
              "7       16     0.703209    0.656895\n",
              "8       18     0.704365    0.649783\n",
              "9       19     0.703209    0.651344"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "data = {'K_value': K_values, 'Train score': trainscore, 'Test score': testscore, }\n",
        "df = pd.DataFrame(data)\n",
        "display(df)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "通过优化权重向量来拟合 Logistic 回归模型，并使用该模型对测试集数据进行预测和评估，最终计算并输出了一些不公平度指标和规则。"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Best k: 16\n"
          ]
        }
      ],
      "source": [
        "# 找到最大Test score对应的K_value\n",
        "max_test_score_index = df['Test score'].idxmax()\n",
        "a = df.loc[max_test_score_index, 'K_value']\n",
        "print(f'Best k: {a}')"
      ]
    },
    {
      "attachments": {
        "image.png": {
          "image/png": "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"
        }
      },
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "![image.png](attachment:image.png)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "zdoyG4ukUCuw"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>ALL</th>\n",
              "      <th>DP</th>\n",
              "      <th>TPR</th>\n",
              "      <th>TNR</th>\n",
              "      <th>FPR</th>\n",
              "      <th>FNR</th>\n",
              "      <th>ACR</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>logistic_reg_Black</th>\n",
              "      <td>907</td>\n",
              "      <td>0.5259</td>\n",
              "      <td>0.6976</td>\n",
              "      <td>0.6454</td>\n",
              "      <td>0.3546</td>\n",
              "      <td>0.3024</td>\n",
              "      <td>0.6714</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                    ALL      DP     TPR     TNR     FPR     FNR     ACR\n",
              "logistic_reg_Black  907  0.5259  0.6976  0.6454  0.3546  0.3024  0.6714"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>ALL</th>\n",
              "      <th>DP</th>\n",
              "      <th>TPR</th>\n",
              "      <th>TNR</th>\n",
              "      <th>FPR</th>\n",
              "      <th>FNR</th>\n",
              "      <th>ACR</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>logistic_reg_White</th>\n",
              "      <td>631</td>\n",
              "      <td>0.3122</td>\n",
              "      <td>0.4542</td>\n",
              "      <td>0.7816</td>\n",
              "      <td>0.2184</td>\n",
              "      <td>0.5458</td>\n",
              "      <td>0.6513</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                    ALL      DP     TPR     TNR     FPR     FNR     ACR\n",
              "logistic_reg_White  631  0.3122  0.4542  0.7816  0.2184  0.5458  0.6513"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>ALL</th>\n",
              "      <th>DP</th>\n",
              "      <th>TPR</th>\n",
              "      <th>TNR</th>\n",
              "      <th>FPR</th>\n",
              "      <th>FNR</th>\n",
              "      <th>ACR</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>logistic_reg_All</th>\n",
              "      <td>1538</td>\n",
              "      <td>0.4382</td>\n",
              "      <td>0.6108</td>\n",
              "      <td>0.7074</td>\n",
              "      <td>0.2926</td>\n",
              "      <td>0.3892</td>\n",
              "      <td>0.6632</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                   ALL      DP     TPR     TNR     FPR     FNR     ACR\n",
              "logistic_reg_All  1538  0.4382  0.6108  0.7074  0.2926  0.3892  0.6632"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Our method: Disparate impact is 21.370673944684505%, disparate FPR is 13.620449802921398%,\n",
            " disparate FNR is 24.338847699708893%, p% rule is 59.36435792907999%.\n"
          ]
        }
      ],
      "source": [
        "iter = 0\n",
        "\n",
        "while dif(wi0, wi1) > 0.0001:\n",
        "    # 创建一个 LogisticRegression 对象 log_reg，并使用训练集数据 train、训练标签 train_label 和初始权重 wi0 进行拟合\n",
        "    log_reg = LogisticRegression(penalty = 'none', dual = False, tol = 1e-4, fit_intercept = False,\n",
        "                            max_iter=400, solver='newton-cg', warm_start = True)\n",
        "    log_reg.fit(train, train_label, wi0)\n",
        "    # 对 train_bp、train_bn、train_wp 和 train_wn 数据分别计算损失值，并将结果存储在 loss_bp、loss_bn、loss_wp 和 loss_wn 中。损失值通过负对数似然函数计算。\n",
        "    for i1 in range(train_bp.shape[0]):\n",
        "        loss_bp[i1] = -math.log(log_reg.predict_proba(train_bp)[i1][1]+1e-100)\n",
        "\n",
        "    for i2 in range(train_bn.shape[0]):\n",
        "        loss_bn[i2] = -math.log(log_reg.predict_proba(train_bn)[i2][0]+1e-100)\n",
        "\n",
        "    for i3 in range(train_wp.shape[0]):\n",
        "        loss_wp[i3] = -math.log(log_reg.predict_proba(train_wp)[i3][1]+1e-100)\n",
        "\n",
        "    for i4 in range(train_wn.shape[0]):\n",
        "        loss_wn[i4] = -math.log(log_reg.predict_proba(train_wn)[i4][0]+1e-100)\n",
        "    # 使用优化函数 optim 分别计算 loss_bp、loss_bn、loss_wp 和 loss_wn 对应的更新后的权重向量，并分别存储在 wi0_bp_1、wi0_bn_1、wi0_wp_1 和 wi0_wn_1 中。\n",
        "    wi1 = wi0\n",
        "    wi0_bp_1 = optim(loss_bp, a, c)\n",
        "    wi0_bn_1 = optim(loss_bn, a, c)\n",
        "    wi0_wp_1 = optim(loss_wp, a, c)\n",
        "    wi0_wn_1 = optim(loss_wn, a, c)\n",
        "\n",
        "    train = pd.concat([train_bp, train_bn, train_wp, train_wn])\n",
        "    # 将 train_bp、train_bn、train_wp 和 train_wn 数据以及对应的标签连接起来，构建更新后的训练集 train 和训练标签 train_label。\n",
        "    train_label = np.concatenate((bp_label, bn_label, wp_label, wn_label))\n",
        "    # 将更新后的权重向量 wi0_bp_1、wi0_bn_1、wi0_wp_1 和 wi0_wn_1 连接起来，构建更新后的权重向量 wi0。\n",
        "    wi0 = np.concatenate((wi0_bp_1, wi0_bn_1, wi0_wp_1, wi0_wn_1))\n",
        "\n",
        "    iter = iter + 1\n",
        "\n",
        "    # 使用训练好的 log_reg 模型对黑人测试集 b_test_x 进行预测，并对预测结果进行评估\n",
        "    log_reg_pred1 = log_reg.predict(b_test_x)\n",
        "    logistic_reg1 = model_eval(b_test_y, log_reg_pred1)\n",
        "    ovl_logreg1 = round(pd.DataFrame([logistic_reg1], index = ['logistic_reg_Black']),4)\n",
        "    display(ovl_logreg1)\n",
        "    # 类似地，对白人测试集 w_test_x 进行预测并评估\n",
        "    log_reg_pred2 = log_reg.predict(w_test_x)\n",
        "    logistic_reg2 = model_eval(w_test_y, log_reg_pred2)\n",
        "    ovl_logreg2 = round(pd.DataFrame([logistic_reg2], index = ['logistic_reg_White']),4)\n",
        "    display(ovl_logreg2)\n",
        "\n",
        "    log_reg_pred3 = log_reg.predict(test_x)\n",
        "    logistic_reg3 = model_eval(test_label, log_reg_pred3)\n",
        "    ovl_logreg3 = round(pd.DataFrame([logistic_reg3], index = ['logistic_reg_All']),4)\n",
        "    display(ovl_logreg3)\n",
        "    # 计算不公平度指标（Disparate Impact，DI）、不公平假正率（Disparate False Positive Rate，DFPR）、不公平假负率（Disparate False Negative Rate，DFNR）和 p% 规则，并将结果存储在 DI、DFPR、DFNR 和 prule 中。\n",
        "    DI = 100 * abs(logistic_reg2['DP'] - logistic_reg1['DP'])\n",
        "    DFPR = 100 * abs(logistic_reg2['TNR'] - logistic_reg1['TNR'])\n",
        "    DFNR = 100 * abs(logistic_reg2['TPR'] - logistic_reg1['TPR'])\n",
        "    prule = 100 * min(logistic_reg2['DP'] / logistic_reg1['DP'], logistic_reg1['DP'] / logistic_reg2['DP'])\n",
        "\n",
        "    print(f'Our method: Iteration {iter-1}, disparate impact is {DI}%, disparate FPR is {DFPR}%,\\n disparate FNR is {DFNR}%, p% rule is {prule}%，\\n disparate accuracy is {DACR}%.')\n",
        "\n",
        "log_reg_pred1 = log_reg.predict(b_test_x)\n",
        "logistic_reg1 = model_eval(b_test_y, log_reg_pred1)\n",
        "ovl_logreg1 = round(pd.DataFrame([logistic_reg1], index = ['logistic_reg_Black']),4)\n",
        "display(ovl_logreg1)\n",
        "\n",
        "log_reg_pred2 = log_reg.predict(w_test_x)\n",
        "logistic_reg2 = model_eval(w_test_y, log_reg_pred2)\n",
        "ovl_logreg2 = round(pd.DataFrame([logistic_reg2], index = ['logistic_reg_White']),4)\n",
        "display(ovl_logreg2)\n",
        "\n",
        "log_reg_pred3 = log_reg.predict(test_x)\n",
        "logistic_reg3 = model_eval(test_label, log_reg_pred3)\n",
        "ovl_logreg3 = round(pd.DataFrame([logistic_reg3], index = ['logistic_reg_All']),4)\n",
        "display(ovl_logreg3)\n",
        "\n",
        "DI = 100 * abs(logistic_reg2['DP'] - logistic_reg1['DP'])\n",
        "DFPR = 100 * abs(logistic_reg2['TNR'] - logistic_reg1['TNR'])\n",
        "DFNR = 100 * abs(logistic_reg2['TPR'] - logistic_reg1['TPR'])\n",
        "prule = 100 * min(logistic_reg2['DP'] / logistic_reg1['DP'], logistic_reg1['DP'] / logistic_reg2['DP'])\n",
        "\n",
        "print(f'Our method: Disparate impact is {DI}%, disparate FPR is {DFPR}%,\\n disparate FNR is {DFNR}%, p% rule is {prule}%.')"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "name": "compas.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.15"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}
